#pragma once

#include <iostream>
#include <ctime> // #include <time.h>
#include <string>
#include <cstring>
#include <vector>
#include <cassert>
#include <functional>
#include <unordered_map>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <typeinfo>
#include <memory>
#include <fcntl.h>
#include <signal.h>
#include <sys/epoll.h>
#include <sys/eventfd.h>
#include <sys/timerfd.h>

// using namespace std;

#define INT 0
#define DBG 1
#define ERR 2
#define LOG_LEVEL DBG // 设置的日志等级

// #define LOG(format, ...) fprintf(stdout, "[%s:%d]" format "\n", __FILE__, __LINE__, __VA_ARGS__);
#define LOG(level, format, ...)                                                                   \
    do                                                                                            \
    {                                                                                             \
        if (level < LOG_LEVEL)                                                                    \
            break;                                                                                \
        time_t t = time(NULL);                                                                    \
        struct tm *ltm = localtime(&t);                                                           \
        char timeBuffer[32] = {0};                                                                \
        strftime(timeBuffer, sizeof(timeBuffer) - 1, "%H:%M:%S", ltm);                            \
        fprintf(stdout, "[%s %s:%d]" format "\n", timeBuffer, __FILE__, __LINE__, ##__VA_ARGS__); \
    } while (0)

// 有对上面的 LOG 宏函数再封装的感觉
#define INT_LOG(format, ...) LOG(INT, format, ##__VA_ARGS__);
#define DBG_LOG(format, ...) LOG(DBG, format, ##__VA_ARGS__);
#define ERR_LOG(format, ...) LOG(ERR, format, ##__VA_ARGS__);

#define BUFFER_DEFAULT_SIZE 1024
class Buffer
{
private:
    std::vector<char> _buffer;
    uint64_t _reader_idx;
    uint64_t _writer_idx;

public:
    Buffer() : _reader_idx(0), _writer_idx(0), _buffer(BUFFER_DEFAULT_SIZE) {}
    // 下面为什么不能直接返回 _buffer.begin(); 呢？
    // _buffer.begin() 返回的是迭代器，解引用才是指向空间起始位置的数据，再取地址才是指向起始空间的地址
    char *Begin() { return &*_buffer.begin(); }
    // 获取当前写入起始地址，_buffer的空间的起始地址，加上写偏移量
    char *WritePosition() { return Begin() + _writer_idx; }
    // 获取当前读取的起始地址
    char *ReadPosition() { return Begin() + _reader_idx; }
    // 获取缓冲区末尾空闲空间大小 -- 写偏移之后的空闲空间，总体空间大小减去写偏移
    uint64_t TailIdleSize() { return _buffer.size() - _writer_idx; }
    // 获取缓冲区起始空闲空间的大小 -- 读偏移之前的空闲空间大小
    uint64_t HeadIdleSize() { return _reader_idx; }
    // 获取可读数据端的大小
    uint64_t ReadAbleSize() { return _writer_idx - _reader_idx; }
    // 将读偏移向后移动
    void MoveReadOffset(uint64_t len)
    {
        if (len == 0)
            return;
        // 向后移动的大小必须小于可读空间的大小
        assert(len <= ReadAbleSize());
        _reader_idx += len;
    }
    // 将写偏移向后移动
    void MoveWriteOffset(uint64_t len)
    {
        if (len == 0)
            return;
        // 写偏移向后移动的大小必须得小于当前后边的空闲空间的大小
        assert(len <= TailIdleSize());
        _writer_idx += len;
    }
    // 确保可写空闲空间足够（整体空闲空间足够了就移动数据，否则就扩容）
    void EnsureWriteSpace(uint64_t len)
    {
        // 如果末尾空闲空间足够的话，直接返回（可以直接写入）
        if (TailIdleSize() >= len)
            return;
        // 末尾空闲空间不够，则判断加上起始空闲空间的大小是否足够，够了就移动数据。不够就扩容
        if (len <= TailIdleSize() + HeadIdleSize())
        {
            // 将数据移动到起始位置
            uint64_t rsz = ReadAbleSize();
            std::copy(ReadPosition(), ReadPosition() + rsz, Begin()); // 把可读数据拷贝到起始位置
            _reader_idx = 0;
            _writer_idx = rsz;
        }
        else
        {
            DBG_LOG("RESIZE %ld", _writer_idx + len);
            _buffer.resize(_writer_idx + len);
        }
    }
    // 写入数据（把 data 里面的 len 长度的数据写入到我们的 _buffer 中）
    void Write(const void *data, uint64_t len)
    {
        // 1. 保证有足够的空间    2. 拷贝数据进去
        if (len == 0)
            return;
        EnsureWriteSpace(len);
        const char *d = (const char *)data;
        std::copy(d, d + len, WritePosition());
    }
    void WriteAndPush(const void *data, uint64_t len)
    {
        Write(data, len);
        MoveWriteOffset(len);
    }
    void WriteString(const std::string &data)
    {
        return Write(data.c_str(), data.size());
    }
    void WriteStringAndPush(const std::string &data)
    {
        // 从 const std::string& data; 中写入数据的大小也就是 data.size(), 所以下面的 _Writer_idx 移动的长度就是 data.size() 的大小咯
        WriteString(data);
        MoveWriteOffset(data.size());
    }
    void WriteBuffer(Buffer &data)
    {
        return Write(data.ReadPosition(), data.ReadAbleSize());
    }
    void WriteBufferAndPush(Buffer &data)
    {
        // 从 Buffer& data; 中写入数据的大小也就是 ReadAbleSize(), 所以下面的 _Writer_idx 移动的长度就是 data.ReadAbleSize() 的大小咯
        WriteBuffer(data);
        MoveWriteOffset(data.ReadAbleSize());
    }

    // 读取数据
    void Read(void *buf, uint64_t len)
    {
        // 要求获取数据的大小必须小于可读空闲空间的大小
        assert(len <= ReadAbleSize());
        std::copy(ReadPosition(), ReadPosition() + len, (char *)buf);
    }
    void ReadAndPop(void *buf, uint64_t len)
    {
        Read(buf, len);
        MoveReadOffset(len);
    }
    std::string ReadAsString(uint64_t len)
    {
        // 要获取的数据大小必须小于可读数据的大小
        assert(len <= ReadAbleSize());
        std::string str;
        str.resize(len);
        Read(&str[0], len);
        return str;
    }
    std::string ReadAsStringAndPop(uint64_t len)
    {
        assert(len <= ReadAbleSize());
        std::string str = ReadAsString(len);
        MoveReadOffset(len);
        return str;
    }
    // 找到 \n ---> 每一次读取一行数据
    char *FindCRLF()
    {
        // void *memchr(const void *s, int c, size_t n);
        // memchr 函数的作用就是在一段字符区间内找到一个字符
        char *res = (char *)memchr(ReadPosition(), '\n', ReadAbleSize());
        return res;
    }
    //
    std::string GetLine()
    {
        char *pos = FindCRLF();
        if (pos == nullptr)
            return "";
        // +1 是为了把后面的换行符也取出来
        return ReadAsString(pos - ReadPosition() + 1);
    }
    std::string GetLineAndPop()
    {
        std::string str = GetLine();
        MoveReadOffset(str.size());
        return str;
    }
    // 清空缓冲区
    void Clear()
    {
        // 只需要将 _writer_idx 和 _reader_idx 偏移即可(数据是覆盖的)
        _writer_idx = _reader_idx = 0;
    }
};

// class Socket 类是套接字管理的
#define MAX_LISTEN 1024
class Socket
{
private:
    int _sockfd;

public:
    Socket() : _sockfd(-1) {}
    Socket(int fd) : _sockfd(fd) {}
    ~Socket() { Close(); }
    int Fd() { return _sockfd; }
    // 创建套接字
    bool Create()
    {
        // int socket(int domain, int type, int protocol)
        _sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        if (_sockfd < 0)
        {
            ERR_LOG("CREATE SOCKET FATLED!!!");
            return false;
        }
        return true;
    }
    // 绑定地址信息
    bool Bind(const std::string &ip, uint64_t port)
    {
        struct sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = inet_addr(ip.c_str());
        socklen_t len = sizeof(struct sockaddr_in);
        // int bind(int sockfd, struct sockaddr* addr, socklen_t len);
        int ret = bind(_sockfd, (struct sockaddr *)&addr, len);
        if (ret < 0)
        {
            ERR_LOG("BIND ADDRESS FAILED!!!");
            return false;
        }
        return true;
    }
    // 开始监听
    bool Listen(int backlog = MAX_LISTEN)
    {
        // int listen(int backlog)
        int ret = listen(_sockfd, backlog);
        if (ret < 0)
        {
            ERR_LOG("SOCKET LISTEN FAILED!!!");
            return false;
        }
        return true;
    }
    // 向服务器发起连接
    bool Connect(const std::string &ip, uint64_t port)
    {
        struct sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = inet_addr(ip.c_str());
        socklen_t len = sizeof(struct sockaddr_in);
        // int connec(int sockfd, struct sockaddr* addr, socklen_t len);
        int ret = connect(_sockfd, (struct sockaddr *)&addr, len);
        if (ret < 0)
        {
            ERR_LOG("CONNECT SERVER FAILED!!!");
            return false;
        }
        return true;
    }
    // 获取新连接
    int Accept()
    {
        // int accept(int sockfd, struct sockaddr* addr, socklen_t len);
        int newfd = accept(_sockfd, NULL, NULL);
        if (newfd < 0)
        {
            ERR_LOG("SOCKET ACCEPT FAILED!!!");
            return -1;
        }
        return newfd;
    }
    // 接收数据
    ssize_t Recv(void *buf, size_t len, int flag = 0)
    {
        // ssize_t recv(int sockfd, void* buf, size_t len, int flag);
        ssize_t ret = recv(_sockfd, buf, len, flag);
        if (ret < 0)
        {
            // EAGAIN 当前 socket 的接收缓冲区中没有数据了，在非阻塞的情况下才会有这个错误
            // EINTR 表示当前 socket 的阻塞等待，被信号打断了
            if (errno == EAGAIN || errno == EINTR)
                return 0; // 表示这次接收没有接收到数据
            ERR_LOG("SOCKET RECV FAILED!!!");
            return -1;
        }
        return ret;
    }
    ssize_t NoBlockRecv(void *buf, size_t len)
    {
        return Recv(buf, len, MSG_DONTWAIT); // MSG_DONTWAIT 表示当前接收为非阻塞
    }
    // 发送数据
    ssize_t Send(const void *buf, size_t len, int flag = 0)
    {
        // ssize_t send(int sockfd, void* buf, size_t len, int flag);
        ssize_t ret = send(_sockfd, buf, len, flag);
        if (ret < 0)
        {
            if (errno == EAGAIN || errno == EINTR)
                return 0;
            ERR_LOG("SOCKET SEND FAILED!!!");
            return -1;
        }
        return ret; // 实际发送数据的长度
    }
    ssize_t NoBlockSend(void *buf, size_t len)
    {
        if (len == 0)
            return 0;
        return Send(buf, len, MSG_DONTWAIT); // MSG_DONTWAIT   表示当前发送为非阻塞
    }
    // 关闭套接字
    void Close()
    {
        if (_sockfd != -1)
        {
            close(_sockfd);
            _sockfd = -1;
        }
    }
    // 创建一个服务端连接
    bool CreateServer(uint64_t port, const std::string &ip = "0.0.0.0", bool block_flag = false)
    {
        // 1. 创建套接字   2. 绑定地址   3. 开始监听   4. 设置非阻塞   5. 启动地址重用
        if (Create() == false)
            return false;
        if (block_flag)
            NonBlock();
        if (Bind(ip, port) == false)
            return false;
        if (Listen() == false)
            return false;
        ResueAddress();
        return true;
    }
    // 创建一个客户端连接
    bool CreateClient(uint64_t port, const std::string &ip)
    {
        // 1. 创建套接字   2.指向连接服务器
        if (Create() == false)
            return false;
        if (Connect(ip, port) == false)
            return false;
        return true;
    }
    // 设置套接字选项 --- 开启地址端口复用
    void ResueAddress()
    {
        // int setsockopt(int fd, intlevel, int optname, void* val, int vallen);
        int val = 1;
        setsockopt(_sockfd, SOL_SOCKET, SO_REUSEADDR, (void *)&val, sizeof(int));
        val = 1;
        setsockopt(_sockfd, SOL_SOCKET, SO_REUSEPORT, (void *)&val, sizeof(int));
    }
    // 设置套接字阻塞属性 --- 设置为非阻塞
    void NonBlock()
    {
        // int fcntl(int fd, int cmd, .../* arg */);
        int flag = fcntl(_sockfd, F_GETFL, 0);
        fcntl(_sockfd, F_SETFL, flag | O_NONBLOCK);
    }
};

// Class Channel 类是用来进行文件描述符事件管理以及事件的处理的
class Poller;
class Channel
{
private:
    int _fd; // 外部传递进来的，需要管理的描述符
    Poller *_poller;
    uint32_t _events;  // 当前需要监控的事件
    uint32_t _revents; // 当前连接触发的事件
    using EventCallback = std::function<void()>;
    EventCallback _read_callback;  // 可读事件被触发的回调函数
    EventCallback _write_callback; // 可写事件被触发的回调函数
    EventCallback _error_callback; // 错误事件被触发的回调函数
    EventCallback _close_callback; // 连接断开被触发的回调函数
    EventCallback _event_callback; // 任意事件被触发的回调函数

public:
    Channel(Poller *poller, int fd) : _poller(poller), _fd(fd), _events(0), _revents(0) {}
    int Fd() { return _fd; }
    uint32_t Events() { return _events; }
    void SetREvents(uint32_t events) { _revents = events; }
    void SetReadCallback(const EventCallback &cb) { _read_callback = cb; }
    void SetWriteCallback(const EventCallback &cb) { _write_callback = cb; }
    void SetErrorCallback(const EventCallback &cb) { _error_callback = cb; }
    void SetCloseCallback(const EventCallback &cb) { _close_callback = cb; }
    void SetEventCallback(const EventCallback &cb) { _event_callback = cb; }
    // 判断当前是否监控了可读
    bool ReadAble() { return _events & EPOLLIN; }
    // 判断当前是否监控了可写
    bool WriteAble() { return _events & EPOLLOUT; }
    // 启动读事件监控
    void EnableRead()
    {
        _events |= EPOLLIN;
        Update();
    }
    // 启动写事件监控
    void EnableWrite()
    {
        _events |= EPOLLOUT;
        Update();
    }
    // 关闭读事件监控
    void DisableRead()
    {
        _events &= ~EPOLLIN;
        Update();
    }
    // 关闭写事件监控
    void DisableWrite()
    {
        _events &= ~EPOLLOUT;
        Update();
    }
    // 关闭是有事件监控
    void DisableAll()
    {
        _events = 0;
        Update();
    }
    // 移除监控
    void Remove();
    void Update();
    // 事件处理，一旦连接触发了事件，就调用这个函数，自己触发了什么事件如何处理自己决定
    void HandleEvent()
    {
        // 下面是一个段错误的示例： Segmentation fault
        // 1. 下面各种回调函数的情况中，因为 _read_callback(), _write_callaback(), _error_callback, _close_callback() 都可能会造成 delete channel, 所以 _event_callback() 放在前面打印了。
        // 2. 下面的各种情况如果不用 if, else if, else if.... 只能执行一个的话，是会出现段错误的（找了好久的报错，不过这样，代码上和标准的代码有些出入了。但是功能上好像没有问题）
        // 用下面注释的写法的话，是会有段错误的。但是标准的写法应该是下面的这种写法
        // if ((_revents & EPOLLIN) || (_revents & EPOLLRDHUP) || (_revents & EPOLLPRI)) {
        //     /*不管任何事件，都调用的回调函数*/
        //     if (_read_callback) _read_callback();
        // }
        //
        // /*有可能会释放连接的操作事件，一次只处理一个*/
        // if (_revents & EPOLLOUT) {
        //     if (_write_callback) _write_callback();
        // }else if (_revents & EPOLLERR) {
        //     if (_error_callback) _error_callback();// NOTE(zhangshuancheng)一旦出错，就会释放连接，因此要放到前边调用任意回调
        // }else if (_revents & EPOLLHUP) {
        //     if (_close_callback) _close_callback();
        // }
        //
        // if (_event_callback) _event_callback();

        // 下面的 std::cout 为找错误时候的打印调试信息的
        if ((_revents & EPOLLIN) || (_revents & EPOLLRDHUP) || (_revents & EPOLLPRI))
        {
            if (_event_callback)
                _event_callback();
            // 不管任何事件都调用的回调函数
            if (_read_callback)
                _read_callback();
        }
        else if (_revents & EPOLLOUT) // 可能会触发连接操作事件，一次只处理一个的哦
        {
            if (_event_callback)
                _event_callback(); //  Segmentation fault

            if (_write_callback)
                _write_callback();
        }
        else if (_revents & EPOLLERR)
        {
            if (_event_callback)
                _event_callback();

            // 一旦出错，就会释放连接，因此要放到前边调用任意回调
            if (_error_callback)
                _error_callback();
        }
        else if (_revents & EPOLLHUP)
        {
            if (_event_callback)
                _event_callback();
            if (_close_callback)
                _close_callback();
        }
        else if (_event_callback)
            _event_callback();
    }
};

// class Poller 类是用来管理多个 Channel 类的
// 其中的 _epfd 用来管理多个描述符
#define MAX_EPOLLEVENTS 1024
class Poller
{
private:
    int _epfd;
    struct epoll_event _evs[MAX_EPOLLEVENTS];
    std::unordered_map<int, Channel *> _channels;

private:
    // 对 epoll 的直接操作
    void Update(Channel *channel, int op)
    {
        // int epoll_ctl(int epfd, int op, int fd, struct eoll_event* ev);
        int fd = channel->Fd();
        struct epoll_event ev;
        ev.data.fd = fd;
        ev.events = channel->Events();
        int ret = epoll_ctl(_epfd, op, fd, &ev);
        if (ret < 0)
            ERR_LOG("EPOLLCTL FAILED!!!");
        return;
    }
    // 判断一个 channel 是否已经添加了事件监控
    bool HasChannel(Channel *channel)
    {
        auto it = _channels.find(channel->Fd());
        if (it == _channels.end())
            return false;
        return true;
    }

public:
    Poller()
    {
        _epfd = epoll_create(MAX_EPOLLEVENTS); // 传递的餐宿没什么用，大于0就可以了
        std::cout << "_epfd: " << _epfd << std::endl;
        if (_epfd < 0)
        {
            ERR_LOG("EPOLL CREATE FAILED!!!");
            abort(); // 退出程序
        }
    }
    // 添加或修改监控事件
    void UpdataEvent(Channel *channel)
    {
        bool ret = HasChannel(channel);
        if (ret == false)
        {
            // 不存在 unordered_map 里面，注意unordered_map和epoll里面都得添加的哦
            _channels.insert(std::make_pair(channel->Fd(), channel));
            return Update(channel, EPOLL_CTL_ADD);
        }
        return Update(channel, EPOLL_CTL_MOD);
    }
    // 移除监控事件
    void RemoveEvent(Channel *channel)
    {
        auto it = _channels.find(channel->Fd());
        if (it != _channels.end())
        {
            // _channels.erase(channel->Fd());
            _channels.erase(it);
        }
        Update(channel, EPOLL_CTL_DEL);
    }
    // 开始监控，返回活跃连接
    void Poll(std::vector<Channel *> *active)
    {
        // int epoll_wait(int epfd, struct epoll_event* evs, int maxevents, int timeout);
        int nfds = epoll_wait(_epfd, _evs, MAX_EPOLLEVENTS, -1); // -1 表示的是阻塞式的 epoll_wait 的哦
        if (nfds < 0)
        {
            if (errno == EINTR)
                return;
            ERR_LOG("EPOLL WAIT ERROR: %s\n", strerror(errno));
            abort(); // 退出程序
        }
        for (int i = 0; i < nfds; i++)
        {
            auto it = _channels.find(_evs[i].data.fd);
            assert(it != _channels.end());
            it->second->SetREvents(_evs[i].events); // 设置实际的就绪事件
            active->push_back(it->second);
        }
        return;
    }
};

void Channel::Remove() { return _poller->RemoveEvent(this); }
void Channel::Update() { return _poller->UpdataEvent(this); }
